type reflect.rtype
170 uses
reflect (current package)
abi.go#L125: func (a *abiSeq) addArg(t *rtype) *abiStep {
abi.go#L166: func (a *abiSeq) addRcvr(rcvr *rtype) (*abiStep, bool) {
abi.go#L199: func (a *abiSeq) regAssign(t *rtype, offset uintptr) bool {
abi.go#L388: func newAbiDesc(t *funcType, rcvr *rtype) abiDesc {
makefunc.go#L108: ftyp := (*funcType)(unsafe.Pointer(v.Type().(*rtype)))
swapper.go#L34: typ := v.Type().Elem().(*rtype)
type.go#L219: common() *rtype
type.go#L315: type rtype struct {
type.go#L362: rtype
type.go#L363: elem *rtype // array element type
type.go#L364: slice *rtype // slice type
type.go#L370: rtype
type.go#L371: elem *rtype // channel element type
type.go#L387: rtype
type.go#L400: rtype
type.go#L407: rtype
type.go#L408: key *rtype // map key type
type.go#L409: elem *rtype // map element (value) type
type.go#L410: bucket *rtype // internal bucket structure
type.go#L421: rtype
type.go#L422: elem *rtype // pointer element (pointed at) type
type.go#L427: rtype
type.go#L428: elem *rtype // slice element type
type.go#L434: typ *rtype // type of field
type.go#L448: rtype
type.go#L713: func resolveReflectType(t *rtype) typeOff {
type.go#L728: func (t *rtype) nameOff(off nameOff) name {
type.go#L732: func (t *rtype) typeOff(off typeOff) *rtype {
type.go#L733: return (*rtype)(resolveTypeOff(unsafe.Pointer(t), int32(off)))
type.go#L736: func (t *rtype) textOff(off textOff) unsafe.Pointer {
type.go#L740: func (t *rtype) uncommon() *uncommonType {
type.go#L791: rtype
type.go#L798: func (t *rtype) String() string {
type.go#L806: func (t *rtype) Size() uintptr { return t.size }
type.go#L808: func (t *rtype) Bits() int {
type.go#L819: func (t *rtype) Align() int { return int(t.align) }
type.go#L821: func (t *rtype) FieldAlign() int { return int(t.fieldAlign) }
type.go#L823: func (t *rtype) Kind() Kind { return Kind(t.kind & kindMask) }
type.go#L825: func (t *rtype) pointers() bool { return t.ptrdata != 0 }
type.go#L827: func (t *rtype) common() *rtype { return t }
type.go#L829: func (t *rtype) exportedMethods() []method {
type.go#L837: func (t *rtype) NumMethod() int {
type.go#L845: func (t *rtype) Method(i int) (m Method) {
type.go#L873: m.Func = Value{mt.(*rtype), fn, fl}
type.go#L879: func (t *rtype) MethodByName(name string) (m Method, ok bool) {
type.go#L897: func (t *rtype) PkgPath() string {
type.go#L908: func (t *rtype) hasName() bool {
type.go#L912: func (t *rtype) Name() string {
type.go#L931: func (t *rtype) ChanDir() ChanDir {
type.go#L939: func (t *rtype) IsVariadic() bool {
type.go#L947: func (t *rtype) Elem() Type {
type.go#L968: func (t *rtype) Field(i int) StructField {
type.go#L976: func (t *rtype) FieldByIndex(index []int) StructField {
type.go#L984: func (t *rtype) FieldByName(name string) (StructField, bool) {
type.go#L992: func (t *rtype) FieldByNameFunc(match func(string) bool) (StructField, bool) {
type.go#L1000: func (t *rtype) In(i int) Type {
type.go#L1008: func (t *rtype) Key() Type {
type.go#L1016: func (t *rtype) Len() int {
type.go#L1024: func (t *rtype) NumField() int {
type.go#L1032: func (t *rtype) NumIn() int {
type.go#L1040: func (t *rtype) NumOut() int {
type.go#L1048: func (t *rtype) Out(i int) Type {
type.go#L1056: func (t *funcType) in() []*rtype {
type.go#L1064: return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.inCount:t.inCount]
type.go#L1067: func (t *funcType) out() []*rtype {
type.go#L1076: return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "outCount > 0"))[t.inCount : t.inCount+outCount : t.inCount+outCount]
type.go#L1345: var ntyp *rtype
type.go#L1442: return t.(*rtype).ptrTo()
type.go#L1445: func (t *rtype) ptrTo() *rtype {
type.go#L1496: func (t *rtype) Implements(u Type) bool {
type.go#L1503: return implements(u.(*rtype), t)
type.go#L1506: func (t *rtype) AssignableTo(u Type) bool {
type.go#L1510: uu := u.(*rtype)
type.go#L1514: func (t *rtype) ConvertibleTo(u Type) bool {
type.go#L1518: uu := u.(*rtype)
type.go#L1522: func (t *rtype) Comparable() bool {
type.go#L1527: func implements(T, V *rtype) bool {
type.go#L1615: func specialChannelAssignability(T, V *rtype) bool {
type.go#L1628: func directlyAssignable(T, V *rtype) bool {
type.go#L1660: func haveIdenticalUnderlyingType(T, V *rtype, cmpTags bool) bool {
type.go#L1770: func rtypeOff(section unsafe.Pointer, off int32) *rtype {
type.go#L1771: return (*rtype)(add(section, uintptr(off), "sizeof(rtype) > 0"))
type.go#L1778: func typesByString(s string) []*rtype {
type.go#L1780: var ret []*rtype
type.go#L1821: t1 *rtype
type.go#L1822: t2 *rtype
type.go#L1843: typ := t.(*rtype)
type.go#L1848: return ch.(*rtype)
type.go#L1906: ktyp := key.(*rtype)
type.go#L1907: etyp := elem.(*rtype)
type.go#L1976: args [4]*rtype
type.go#L1980: args [8]*rtype
type.go#L1984: args [16]*rtype
type.go#L1988: args [32]*rtype
type.go#L1992: args [64]*rtype
type.go#L1996: args [128]*rtype
type.go#L2017: var args []*rtype
type.go#L2051: t := in.(*rtype)
type.go#L2060: t := out.(*rtype)
type.go#L2077: for _, t := range ts.([]*rtype) {
type.go#L2088: for _, t := range ts.([]*rtype) {
type.go#L2095: addToCache := func(tt *rtype) Type {
type.go#L2096: var rts []*rtype
type.go#L2098: rts = rti.([]*rtype)
type.go#L2154: func isReflexive(t *rtype) bool {
type.go#L2178: func needKeyUpdate(t *rtype) bool {
type.go#L2205: func hashMightPanic(t *rtype) bool {
type.go#L2235: func bucketOf(ktyp, etyp *rtype) *rtype {
type.go#L2237: ktyp = PointerTo(ktyp).(*rtype)
type.go#L2240: etyp = PointerTo(etyp).(*rtype)
type.go#L2284: b := &rtype{
type.go#L2299: func (t *rtype) gcSlice(begin, end uintptr) []byte {
type.go#L2305: func emitGCMask(out []byte, base uintptr, typ *rtype, n uintptr) {
type.go#L2324: func appendGCProg(dst []byte, typ *rtype) []byte {
type.go#L2351: typ := t.(*rtype)
type.go#L2863: func typeptrdata(t *rtype) uintptr {
type.go#L2899: typ := elem.(*rtype)
type.go#L2943: array.slice = SliceOf(elem).(*rtype)
type.go#L3039: func toType(t *rtype) Type {
type.go#L3048: rcvr *rtype // receiver type, or nil if none
type.go#L3052: t *rtype
type.go#L3066: func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, framePool *sync.Pool, abi abiDesc) {
type.go#L3083: x := &rtype{
type.go#L3118: func ifaceIndir(t *rtype) bool {
type.go#L3137: func addTypeBits(bv *bitVector, offset uintptr, t *rtype) {
value.go#L41: typ *rtype
value.go#L197: typ *rtype
value.go#L205: ityp *rtype // static interface type
value.go#L206: typ *rtype // dynamic concrete type
value.go#L365: rcvrtype *rtype
value.go#L490: targ := t.In(i).(*rtype)
value.go#L847: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *rtype, t *funcType, fn unsafe.Pointer) {
value.go#L1338: var uint8Type = TypeOf(uint8(0)).(*rtype)
value.go#L1586: var stringType = TypeOf("").(*rtype)
value.go#L1829: func copyVal(typ *rtype, fl flag, ptr unsafe.Pointer) Value {
value.go#L2736: typ *rtype // channel type
value.go#L2892: func unsafe_New(*rtype) unsafe.Pointer
value.go#L2893: func unsafe_NewArray(*rtype, int) unsafe.Pointer
value.go#L2911: s := unsafeheader.Slice{Data: unsafe_NewArray(typ.Elem().(*rtype), cap), Len: len, Cap: cap}
value.go#L2912: return Value{typ.(*rtype), unsafe.Pointer(&s), flagIndir | flag(Slice)}
value.go#L2926: t := typ.(*rtype)
value.go#L2942: t := typ.(*rtype)
value.go#L2982: t := typ.(*rtype)
value.go#L3008: t := typ.(*rtype)
value.go#L3023: t := typ.(*rtype)
value.go#L3031: func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value {
value.go#L3102: func convertOp(dst, src *rtype) func(Value, Type) Value {
value.go#L3389: ifaceE2I(typ.(*rtype), x, target)
value.go#L3423: func makechan(typ *rtype, size int) (ch unsafe.Pointer)
value.go#L3424: func makemap(t *rtype, cap int) (m unsafe.Pointer)
value.go#L3427: func mapaccess(t *rtype, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
value.go#L3430: func mapaccess_faststr(t *rtype, m unsafe.Pointer, key string) (val unsafe.Pointer)
value.go#L3433: func mapassign(t *rtype, m unsafe.Pointer, key, val unsafe.Pointer)
value.go#L3436: func mapassign_faststr(t *rtype, m unsafe.Pointer, key string, val unsafe.Pointer)
value.go#L3439: func mapdelete(t *rtype, m unsafe.Pointer, key unsafe.Pointer)
value.go#L3442: func mapdelete_faststr(t *rtype, m unsafe.Pointer, key string)
value.go#L3445: func mapiterinit(t *rtype, m unsafe.Pointer, it *hiter)
value.go#L3484: func call(stackArgsType *rtype, f, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
value.go#L3486: func ifaceE2I(t *rtype, src any, dst unsafe.Pointer)
value.go#L3494: func typedmemmove(t *rtype, dst, src unsafe.Pointer)
value.go#L3499: func typedmemmovepartial(t *rtype, dst, src unsafe.Pointer, off, size uintptr)
value.go#L3503: func typedmemclr(t *rtype, ptr unsafe.Pointer)
value.go#L3508: func typedmemclrpartial(t *rtype, ptr unsafe.Pointer, off, size uintptr)
value.go#L3513: func typedslicecopy(elemType *rtype, dst, src unsafeheader.Slice) int
value.go#L3516: func typehash(t *rtype, p unsafe.Pointer, h uintptr) uintptr